home *** CD-ROM | disk | FTP | other *** search
/ Chip 2004 December / 2004-12 CHIP.iso / Internet / NVU 0.50 for Windows / nvu-0.50-win32-installer-full.exe / {app} / chrome / comm.jar / content / editor / ftpDirParser.js < prev    next >
Encoding:
Text File  |  2004-02-09  |  9.3 KB  |  356 lines
  1. /* ***** BEGIN LICENSE BLOCK *****
  2.  * Version: MPL 1.1/GPL 2.0/LGPL 2.1
  3.  *
  4.  * The contents of this file are subject to the Mozilla Public License Version
  5.  * 1.1 (the "License"); you may not use this file except in compliance with
  6.  * the License. You may obtain a copy of the License at
  7.  * http://www.mozilla.org/MPL/
  8.  *
  9.  * Software distributed under the License is distributed on an "AS IS" basis,
  10.  * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License
  11.  * for the specific language governing rights and limitations under the
  12.  * License.
  13.  *
  14.  * The Original Code is Nvu.
  15.  *
  16.  * The Initial Developer of the Original Code is
  17.  * Lindows.com.
  18.  * Portions created by the Initial Developer are Copyright (C) 2004
  19.  * the Initial Developer. All Rights Reserved.
  20.  *
  21.  * Contributor(s):
  22.  *   Daniel Glazman (glazman@disruptive-innovations.com), on behalf of Lindows.com
  23.  *
  24.  * Alternatively, the contents of this file may be used under the terms of
  25.  * either the GNU General Public License Version 2 or later (the "GPL"), or
  26.  * the GNU Lesser General Public License Version 2.1 or later (the "LGPL"),
  27.  * in which case the provisions of the GPL or the LGPL are applicable instead
  28.  * of those above. If you wish to allow use of your version of this file only
  29.  * under the terms of either the GPL or the LGPL, and not to allow others to
  30.  * use your version of this file under the terms of the MPL, indicate your
  31.  * decision by deleting the provisions above and replace them with the notice
  32.  * and other provisions required by the GPL or the LGPL. If you do not delete
  33.  * the provisions above, a recipient may use your version of this file under
  34.  * the terms of any one of the MPL, the GPL or the LGPL.
  35.  *
  36.  * ***** END LICENSE BLOCK ***** */
  37.  
  38. const DI_CTRID              = "@mozilla.org/dirIndex;1";
  39. const cnsIDirIndex          = Components.interfaces.nsIDirIndex;
  40.  
  41. const FILENAME_ENTRY        = 1;
  42. const DESCRIPTION_ENTRY     = 2;
  43. const CONTENT_LENGTH_ENTRY  = 3;
  44. const LAST_MODIFIED_ENTRY   = 4;
  45. const CONTENT_TYPE_ENTRY    = 5;
  46. const FILE_TYPE_ENTRY       = 6;
  47. const UNKNOWN_ENTRY         = 7;
  48.  
  49. const UNKNOWN_TOKEN         = 0;
  50. const WS_TOKEN              = 1;
  51. const EOL_TOKEN             = 2;
  52.  
  53. // PUBLIC
  54. // this is the function you have to call to retrieve an FTP dir,
  55. // parse its contents and feed it to a callback; requestData
  56. // is your own data, the parser does not deal with it.
  57. // the callback takes 3 parameters : a string for the URL,
  58. // an nsIDirIndex and your requestData
  59.  
  60. function FTPDirParser(url, requestData,
  61.                       entryCallback, endCallback, errorCallback)
  62. {
  63.   this.url            = url;
  64.   this.callback       = entryCallback;
  65.   this.rqData         = requestData;
  66.   this.endCallback    = endCallback;
  67.   this.errorCallback  = errorCallback;
  68.  
  69.   this.comment = "";
  70.  
  71.   this.dataIndex = 0;
  72.   this.nextToken = UNKNOWN_TOKEN;
  73.  
  74.   loadURL(url, this);
  75.  
  76. }
  77.  
  78. // PUBLIC
  79. // unescapes all %xx contained into a string
  80. function ecmaUnescape(str)
  81. {
  82.     function replaceEscapes(seq)
  83.     {
  84.         var ary = seq.match(/([\da-f]{1,2})(.*)|u([\da-f]{1,4})/);
  85.         if (!ary)
  86.             return "<ERROR>";
  87.  
  88.         if (ary[1])
  89.         {
  90.             // two digit escape, possibly with cruft after
  91.             rv = String.fromCharCode(parseInt(ary[1], 16)) + ary[2];
  92.         }
  93.         else
  94.         {
  95.             // four digits, no cruft
  96.             rv = String.fromCharCode(parseInt(ary[3], 16));
  97.         }
  98.  
  99.         return rv;
  100.     };
  101.  
  102.     // Replace the escape sequences %X, %XX, %uX, %uXX, %uXXX, and %uXXXX with
  103.     // the characters they represent, where X is a hexadecimal digit.
  104.     // See section B.2.2 of ECMA-262 rev3 for more information.
  105.     return str.replace(/%u?([\da-f]{1,4})/ig, replaceEscapes);
  106. }
  107.  
  108.  
  109. function UnEscape(s)
  110. {
  111.   var u = "", l = s.length, i;
  112.   for (i = 0; i < l; i++)
  113.   {
  114.     var c = s[i];
  115.     if (c == "%")
  116.     {
  117.       c = String.fromCharCode(Number("0x" + s.substr(i+1, 2)));
  118.       i += 2;
  119.     }
  120.     u += c;
  121.   }
  122.   return u;
  123. }
  124.  
  125. // PRIVATE
  126. // parse the first 3 chars of a header line
  127. // returns the header code if ok or 0
  128.  
  129. FTPDirParser.prototype.getHeaderToken =
  130. function (data)
  131. {
  132.   if (this.dataIndex < data.length - 3)
  133.   {
  134.     var substr = data.substr(this.dataIndex, 3);
  135.  
  136.     if (data[this.dataIndex+3] == ":" &&
  137.         (substr == "100" ||
  138.          substr == "101" ||
  139.          substr == "102" ||
  140.          substr == "200" ||
  141.          substr == "201" ||
  142.          substr == "300" ||
  143.          substr == "301"))
  144.     {
  145.       this.dataIndex += 4;
  146.       return Number(substr);
  147.     }
  148.   }
  149.   this.dataIndex++;
  150.   return 0;
  151. }
  152.  
  153. // PRIVATE
  154. // skip whitespaces
  155.  
  156. FTPDirParser.prototype.skipWS =
  157. function (data)
  158. {
  159.   while (this.dataIndex < data.length &&
  160.          data[this.dataIndex] == " ")
  161.     this.dataIndex++
  162. }
  163.  
  164. // PRIVATE
  165. // skip everything until end of line
  166.  
  167. FTPDirParser.prototype.skipEndOfLine =
  168. function (data)
  169. {
  170.   while (this.dataIndex < data.length &&
  171.          data[this.dataIndex] != "\r" &&
  172.          data[this.dataIndex] != "\n")
  173.     this.dataIndex++
  174.   while (this.dataIndex < data.length && (
  175.          data[this.dataIndex] == "\r" ||
  176.          data[this.dataIndex] == "\n"))
  177.     this.dataIndex++
  178. }
  179.  
  180. // PRIVATE
  181. // store everything until end of line into comment
  182.  
  183. FTPDirParser.prototype.getCommentLine =
  184. function (data)
  185. {
  186.   this.skipWS(data);
  187.   while (this.dataIndex < data.length &&
  188.          data[this.dataIndex] != "\r" &&
  189.          data[this.dataIndex] != "\n")
  190.   {
  191.     this.comment += data[this.dataIndex];
  192.     this.dataIndex++;
  193.   }
  194.   this.skipEndOfLine(data);
  195. } 
  196.  
  197. // PRIVATE
  198. // parse a 200 line containing the format of 201 lines
  199. // stores it into this.entries array
  200.  
  201. FTPDirParser.prototype.getFormat =
  202. function (data)
  203. {
  204.   var token;
  205.  
  206.   // in case of multiple 200 lines, keep only last one...
  207.   delete this.entries;
  208.   this.entries = new Array();
  209.  
  210.   while (data[this.dataIndex] != "\r" &&
  211.          data[this.dataIndex] != "\n")
  212.   {
  213.     this.skipWS(data);
  214.     token = "";
  215.     while (this.dataIndex < data.length &&
  216.            data[this.dataIndex] != " " &&
  217.            data[this.dataIndex] != "\r" &&
  218.            data[this.dataIndex] != "\n")
  219.     {
  220.       token += data[this.dataIndex];
  221.       this.dataIndex++;
  222.     }
  223.     token = token.toLowerCase();
  224.     if (token == "filename")
  225.       this.entries.push(FILENAME_ENTRY);
  226.     else if (token == "description")
  227.       this.entries.push(DESCRIPTION_ENTRY);
  228.     else if (token == "content-length")
  229.       this.entries.push(CONTENT_LENGTH_ENTRY);
  230.     else if (token == "description")
  231.       this.entries.push(LAST_MODIFIED_ENTRY);
  232.     else if (token == "last-modified")
  233.       this.entries.push(LAST_MODIFIED_ENTRY);
  234.     else if (token == "content-type")
  235.       this.entries.push(CONTENT_TYPE_ENTRY);
  236.     else if (token == "file-type")
  237.       this.entries.push(FILE_TYPE_ENTRY);
  238.     else 
  239.       this.entries.push(UNKNOWN_ENTRY);
  240.  
  241.   }
  242.   this.skipEndOfLine(data);
  243. }
  244.  
  245. // PRIVATE
  246. // parse a 201 line according to a previously parsed 200 line
  247. // returns an nsIDirIndex instance
  248.  
  249. FTPDirParser.prototype.getDataLine =
  250. function (data)
  251. {
  252.   var numberFields = this.entries.length;
  253.   var l = data.length;
  254.   var i;
  255.   var dirIndex = 
  256.     Components.classes[DI_CTRID].createInstance(cnsIDirIndex);
  257.  
  258.   for (i = 0; i < numberFields; i++)
  259.   {
  260.     this.skipWS(data);
  261.     var token = "";
  262.     if (data[this.dataIndex] == '"')
  263.     {
  264.       this.dataIndex++;
  265.       while (this.dataIndex < l &&
  266.              data[this.dataIndex] != '"')
  267.       {
  268.         token += data[this.dataIndex];
  269.         this.dataIndex++;
  270.       }
  271.       this.dataIndex++;
  272.     }
  273.     else
  274.     {
  275.       while (this.dataIndex < l &&
  276.              data[this.dataIndex] != " ")
  277.       {
  278.         token += data[this.dataIndex];
  279.         this.dataIndex++;
  280.       }
  281.     }
  282.  
  283.     switch (this.entries[i])
  284.     {
  285.       case FILENAME_ENTRY:
  286.         dirIndex.location = UnEscape(token);
  287.         break;
  288.       case DESCRIPTION_ENTRY:
  289.         // we do nothing here, we use the nsIDirIndex description attribute
  290.         // for the last-modified date
  291.         break;
  292.       case CONTENT_LENGTH_ENTRY:
  293.         dirIndex.size = Number(token);
  294.         break;
  295.       case LAST_MODIFIED_ENTRY:
  296.         dirIndex.description = UnEscape(token);
  297.         break;
  298.       case CONTENT_TYPE_ENTRY:
  299.         dirIndex.contentType = UnEscape(token);
  300.         break;
  301.       case FILE_TYPE_ENTRY:
  302.         if (token == "FILE")
  303.           dirIndex.type = cnsIDirIndex.TYPE_FILE;
  304.         else if (token == "DIRECTORY")
  305.           dirIndex.type = cnsIDirIndex.TYPE_DIRECTORY;
  306.         else if (token == "SYMBOLIC-LINK")
  307.           dirIndex.type = cnsIDirIndex.TYPE_SYMLINK;
  308.         else
  309.           dirIndex.type = cnsIDirIndex.TYPE_UNKNOWN; // XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX
  310.         break;
  311.       default:
  312.         break;      
  313.     }
  314.   }
  315.   this.skipEndOfLine(data);
  316.   return dirIndex;
  317. }
  318.  
  319. // PRIVATE
  320. // parses all the data coming from an async list of an FTP dir
  321. // calls the provided callback on entries
  322.  
  323. FTPDirParser.prototype.parseData =
  324. function (data, requestData)
  325. {
  326.    var token;
  327.    while (this.dataIndex < data.length)
  328.    {
  329.      token = this.getHeaderToken(data);
  330.      switch (token)
  331.      {
  332.      case 100:
  333.      case 300:
  334.        this.skipEndOfLine(data);
  335.        break;
  336.      case 101:
  337.      case 102:
  338.        this.getCommentLine(data);
  339.        breal;
  340.      case 200:
  341.        this.getFormat(data);
  342.        break;
  343.      case 201:
  344.        var dirEntry = this.getDataLine(data);
  345.  
  346.        if (this.callback)
  347.          this.callback(this.url, dirEntry, this.rqData);
  348.        break;
  349.      default:
  350.        // error, but are we supposed to run this?
  351.        break
  352.      }
  353.    }
  354. }
  355.  
  356.